/**
 * 根据给定的ID查找树中的标签
 * 
 * @param {Object[]} tree - 树数据数组
 * @param {string} id - 需要查找的节点ID
 * @returns {string|null} - 返回找到的节点面包屑
 */
export function findTreeBreadCrumbsLabel(tree, id) {
  for (const node of tree) {
    const _node = { ...node }
    if (_node.id === id) {
      return _node.name
    }

    if (Array.isArray(_node.children) && _node.children.length > 0) {
      const child_path = findTreeBreadCrumbsLabel(_node.children, id)
      if (child_path) {
        return _node.name + ' > ' + child_path
      }
    }
  }
}

/**
 * 查找树中指定id节点的深度
 * 
 * @param {Array} tree - 树结构数据
 * @param {string|number} id - 要查找的节点id
 * @returns {number} - 返回节点的深度，如果找不到返回0
 */
export function findTreeDeep(tree, id) {
  const deep = 1
  for (const node of tree) {
    const _node = { ...node }
    if (_node.id === id) {
      return deep
    }

    if (Array.isArray(_node.children) && _node.children.length > 0) {
      const child_path = findTreeDeep(_node.children, id)
      if (child_path) {
        return deep + 1
      }
    }
  }
  return deep
}


/**
 * 根据给定的ID查找树中的对象
 * 
 * @param {Object[]} tree - 树数据数组
 * @param {string} id - 需要查找的节点ID
 * @returns {Object|null} - 返回找到的节点对象
 */
export function findTreeObject(tree, id, { key = 'id' }) {
  for (const node of tree) {
    const _node = { ...node }
    if (_node[key] === id) {
      return _node
    }

    if (Array.isArray(_node.children) && _node.children.length > 0) {
      const child_path = findTreeObject(_node.children, id, { key })
      if (child_path) {
        return child_path
      }
    }
  }
}

/**
 *  根据给定的ID查找树中的顶级对象
 * 
 * @param {Object[]} tree - 树数据数组
 * @param {string} id - 需要查找的节点ID
 * @returns {Object|null} - 返回找到的节点顶级对象
 */
export function findTreeTopObject(tree, id) {
  const node = findTreeObject(tree, id)
  if (!node) {
    return null
  }

  if (node.parentId) {
    return findTreeTopObject(tree, node.parentId)
  }

  return node
}

/**
 * 通过深度优先搜索算法从树结构中获取自定义对象
 * 
 * @param {Array} tree - 树结构数据
 * @param {string} id - 需要查找的节点ID
 * @returns {Object} - 包含找到节点及其路径信息的对象
 */
export function getDfsCustomObject(tree, id) {
  const res = {}
  const default_loop = 5
  /**
   * 深度优先搜索函数
   * 
   * @param {Array} tree - 当前搜索的树结构数据
   * @param {number} level - 当前搜索的层级
   * @param {Array} path - 当前节点的路径
   * @returns {boolean} - 是否找到了目标节点
   */
  function dfs(tree, level, path) {
    for (const node of tree) {
      const _node = { ...node, children: node.children ? [...node.children] : [] }
      const current_path = [...path, { id: _node.id, name: _node.name }]

      if (_node.id === id) {
        current_path.forEach((item, index) => {
          res[`category${index + 1}Id`] = item.id
          res[`category${index + 1}Name`] = item.name
        })
        return true
      }

      if (dfs(_node.children, level + 1, current_path)) {
        return true
      }
    }
  }

  dfs(tree, 0, [])

  return res
}

/**
 * 获取树结构中指定ID的节点到根节点的路径,用于设备库的关联子系统回显
 * 
 * @param {Object} tree - 树结构对象
 * @param {string} ids - 要查找的节点的IDs
 * @returns {Array} - 包含从指定节点到根节点的ID数组[[id1,id2],[id3,id4]]
 */
/* export function getTreePathArray(tree, ids) {
  const result = []
  for (const node of tree) {
    const _node = { ...node }
    if (!_node.proposalSystemFuncList) {
    }
    if (_node.proposalSystemFuncList) {
      return getTreePathArray(_node.proposalSystemFuncList, ids)
    }
    if (ids.includes(_node.funcId)) {
      result.push([_node.systemId, _node.funcId])
      continue
    }
  }
  return result
}
 */